Jetson Orin NX + Prophesee GenX320

Event Cameras
Developer Guide from RidgeRun

Contents Pin

Jetson Orin NX + Prophesee GenX320

This guide explains how to build and deploy the Prophesee's Event-Based Metavision® Sensor GENX320 driver for a Jetson Orin NX running JetPack 6.2.1.

These instructions target:

JetPack 6.2.1
Jetson Linux R36.4.4
Linux kernel 5.15.148-tegra
Jetson Orin NX (tegra234, P3767 family)

The overall process is:

Download the NVIDIA Jetson Linux public kernel sources
Apply the RidgeRun GenX320 kernel patch
Build the kernel modules and device-tree blobs
Copy the generated artifacts to the Jetson Orin NX and enable the camera overlay
Build and install OpenEB with the RidgeRun OpenEB patch
Configure the runtime environment
Run a basic OpenEB application

For additional background, refer to:

Hardware Setup

Required Hardware

Prophesee GenX320 camera module
NVIDIA Jetson Orin NX Developer Kit flashed with JetPack 6.2.1
Linux host PC with Internet access for building the kernel
Ethernet or USB network connection between the host PC and the Jetson target

Setup

Connect the GenX320 camera module to the NVIDIA Jetson Orin NX Developer Kit using the Jetson 24-pin CSI connector and the appropriate MIPI CSI-2 cable.

When connecting the camera, verify the flex cable orientation against the developer kit documentation and keep the system powered off while making the connection.

Before continuing, make sure the Jetson Orin NX has already booted successfully with JetPack 6.2.1.

Software Installation

All kernel build steps in this section are executed on the Host PC unless stated otherwise. These steps were verified on a Host PC with Ubuntu 20.04 and Ubuntu 24.04.

Step 1: Prepare the Host Build Environment

Install the basic host-side packages:

sudo apt update
sudo apt -y install git-core build-essential bc wget patch

Before running the remaining commands in this guide, set the user-dependent variables for your environment:

export JETSON_ORIN_NX_IP_ADDRESS="<Your_Jetson_board_IP_address>"
e.g. export JETSON_ORIN_NX_IP_ADDRESS="192.168.1.8"
export RIDGERUN_GENX320_REPOSITORY_URL="https://github.com/RidgeRun/genx320-jetson.git"
export GENX320_KERNEL_PATCH_FILENAME="orin-nx/6.2.1_nx_genx320_v0.1.0.patch"
export RIDGERUN_OPENEB_PATCH_FILENAME="orin-nx/openeb-5.1.1-jetson.patch"

Set the build variables:

export JP_VERSION="6.2.1"
export L4T_VERSION="36.4.4"
export L4T_TAG="jetson_36.4.4"

export TOOLCHAIN_ROOT="$HOME/l4t-gcc"
export TOOLCHAIN_PREFIX="$TOOLCHAIN_ROOT/aarch64--glibc--stable-2022.08-1/bin/aarch64-buildroot-linux-gnu-"

export SRC_DL_ROOT="$HOME/jetpack-${JP_VERSION}-kernel-src"
export L4T_SRC_ROOT="$HOME/jetpack-${JP_VERSION}-kernel"

export RIDGERUN_REPO_DIR="$HOME/genx320-jetson"

export DRIVER_MODULE_NAME="nv_genx320"
export OVERLAY_DTBO_NAME="tegra234-p3767-camera-p3768-genx320-dual"
export SENSOR_COMPATIBLE="prophesee,genx320"

export TARGET_USER="<user>"
e.g. export TARGET_USER="nvidia"
export TARGET="${TARGET_USER}@${JETSON_ORIN_NX_IP_ADDRESS}"

Step 2: Download and Extract the NVIDIA Toolchain

Download the Bootlin cross-toolchain used by Jetson Linux R36.4.4:

mkdir -p "$TOOLCHAIN_ROOT"
cd "$TOOLCHAIN_ROOT"
wget https://toolchains.bootlin.com/downloads/releases/toolchains/aarch64/tarballs/aarch64--glibc--stable-2022.08-1.tar.bz2
tar xf aarch64--glibc--stable-2022.08-1.tar.bz2

Optional verification:

test -x "${TOOLCHAIN_PREFIX}gcc" && "${TOOLCHAIN_PREFIX}gcc" --version

Expected output:

aarch64-buildroot-linux-gnu-gcc.br_real (Buildroot 2021.11-4428-g6b6741b) 11.3.0
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Step 3: Download the NVIDIA Kernel Sources

Download the Jetson Linux public sources package for JetPack 6.2.1 / Jetson Linux R36.4.4:

mkdir -p "$SRC_DL_ROOT"
cd "$SRC_DL_ROOT"
wget https://developer.nvidia.com/downloads/embedded/l4t/r36_release_v4.4/sources/public_sources.tbz2
tar xf public_sources.tbz2

mkdir -p "$L4T_SRC_ROOT"
tar xf Linux_for_Tegra/source/kernel_src.tbz2 -C "$L4T_SRC_ROOT"
tar xf Linux_for_Tegra/source/kernel_oot_modules_src.tbz2 -C "$L4T_SRC_ROOT"
tar xf Linux_for_Tegra/source/nvidia_kernel_display_driver_source.tbz2 -C "$L4T_SRC_ROOT"

After extraction, the source tree should contain at least these directories:

kernel
nvidia-oot
hardware/nvidia/t23x/nv-public/overlay

Step 4: Apply the RidgeRun GenX320 Kernel Patch

Clone the RidgeRun repository that contains the Jetson patch:

git clone "$RIDGERUN_GENX320_REPOSITORY_URL" "$RIDGERUN_REPO_DIR"
test -f "$RIDGERUN_REPO_DIR/$GENX320_KERNEL_PATCH_FILENAME"

Apply the kernel patch at the root of the NVIDIA source tree:

patch -d "$L4T_SRC_ROOT" -p1 < "$RIDGERUN_REPO_DIR/$GENX320_KERNEL_PATCH_FILENAME"

Step 5: Build the Kernel, Modules and Device Trees

Set the common build environment:

cd "$L4T_SRC_ROOT"
export ARCH=arm64
export CROSS_COMPILE="$TOOLCHAIN_PREFIX"
export KERNEL_HEADERS="$PWD/kernel/kernel-jammy-src"
export INSTALL_MOD_PATH="${PWD}/rootfs"

Build the NVIDIA kernel:

mkdir -p "$INSTALL_MOD_PATH"
mkdir -p "$INSTALL_MOD_PATH/boot"

cd "$KERNEL_HEADERS"
make defconfig
make -j"$(nproc)"
make modules_prepare
make modules
make modules_install INSTALL_MOD_PATH="$L4T_SRC_ROOT/rootfs"

cp arch/arm64/boot/Image "$L4T_SRC_ROOT/rootfs/boot/"

Build the NVIDIA out-of-tree modules:

cd "$L4T_SRC_ROOT"
make modules
make modules_install

Build the DTBs and DTBOs:

cd "$L4T_SRC_ROOT"
make dtbs

Expected output artifacts:

nvidia-oot/drivers/media/i2c/nv_genx320.ko
kernel-devicetree/generic-dts/dtbs/tegra234-p3767-camera-p3768-genx320-dual.dtbo

Step 6: Copy the Generated Artifacts to the Jetson Orin NX

Copy the module and overlay to the target board:

cd "$L4T_SRC_ROOT"

scp nvidia-oot/drivers/media/i2c/nv_genx320.ko \
  "$TARGET:/tmp/nv_genx320.ko"

scp kernel-devicetree/generic-dts/dtbs/tegra234-p3767-camera-p3768-genx320-dual.dtbo \
  "$TARGET:/tmp/tegra234-p3767-camera-p3768-genx320-dual.dtbo"

Step 7: Install and Enable the Driver on the Jetson Orin NX

The following steps are executed on the Jetson Orin NX target.

Install the copied artifacts:

sudo install -m 0644 /tmp/tegra234-p3767-camera-p3768-genx320-dual.dtbo \
  /boot/tegra234-p3767-camera-p3768-genx320-dual.dtbo

KERNEL_RELEASE="$(uname -r)"   # JetPack 6.2.1 default: 5.15.148-tegra

sudo install -D -m 0644 /tmp/nv_genx320.ko \
  /lib/modules/${KERNEL_RELEASE}/updates/drivers/media/i2c/nv_genx320.ko

sudo depmod -a

Enable the camera overlay with Jetson-IO:

sudo /opt/nvidia/jetson-io/jetson-io.py

In Jetson-IO:

Select Jetson 24pin CSI Connector
Enable the overlay Jetson Camera GENX320 Dual
Save the configuration
Reboot the Jetson

Step 8: Validate the Driver on the Jetson Orin NX

If needed, install the required tools:

sudo apt update
sudo apt -y install v4l-utils gstreamer1.0-tools gstreamer1.0-plugins-base

After reboot, validate that the driver and overlay are active:

DT_BASE=/sys/firmware/devicetree/base
grep -RIlas "$SENSOR_COMPATIBLE" "$DT_BASE" || echo "compatible not found in active DT"

dmesg | grep -Ei "genx320|genx320|camera|i2c"

v4l2-ctl --list-devices
media-ctl -p

Run a basic GStreamer pipeline:

gst-launch-1.0 v4l2src ! fakesink silent=false -v

If the pipeline is working correctly, fakesink should print continuous log messages, typically one line per received buffer.

Step 9: Build and Install OpenEB

The following steps are executed on the Jetson Orin NX target.

Install the required OpenEB dependencies:

sudo apt update
sudo apt -y install apt-utils build-essential software-properties-common wget unzip curl git cmake
sudo apt -y install libopencv-dev libboost-all-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler
sudo apt -y install libhdf5-dev hdf5-tools libglew-dev libglfw3-dev libcanberra-gtk-module ffmpeg pybind11-dev python3-dev

Clone OpenEB and the RidgeRun repository:

export OPENEB_BRANCH="5.1.1"
export OPENEB_SRC_DIR="$HOME/openeb"

git clone https://github.com/prophesee-ai/openeb.git --branch "$OPENEB_BRANCH" "$OPENEB_SRC_DIR"
git clone "$RIDGERUN_GENX320_REPOSITORY_URL" "$RIDGERUN_REPO_DIR"
test -f "$RIDGERUN_REPO_DIR/$RIDGERUN_OPENEB_PATCH_FILENAME"

Apply the RidgeRun OpenEB patch:

patch -d "$OPENEB_SRC_DIR" -p1 < "$RIDGERUN_REPO_DIR/$RIDGERUN_OPENEB_PATCH_FILENAME"

Configure, build, and install OpenEB:

mkdir -p "$OPENEB_SRC_DIR/build"
cd "$OPENEB_SRC_DIR/build"

cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF
cmake --build . --config Release -- -j 4
sudo cmake --build . --target install

Install the udev rules and refresh them:

sudo cp "$OPENEB_SRC_DIR"/hal_psee_plugins/resources/rules/*.rules /etc/udev/rules.d
sudo udevadm control --reload-rules
sudo udevadm trigger

Step 10: Configure the Runtime Environment

Add the required environment variables to ~/.bashrc:

cat <<'EOF' >> ~/.bashrc

# OpenEB / Prophesee runtime environment
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/lib"
export HDF5_PLUGIN_PATH="$HDF5_PLUGIN_PATH:/usr/local/hdf5/lib/plugin"
export MV_HAL_PLUGIN_PATH="${MV_HAL_PLUGIN_PATH:-/usr/local/lib/metavision/hal/plugins}"
export PSEE_VAR_V4L2_BSIZE=1
EOF

Reload the shell configuration:

source ~/.bashrc

Running Basic Examples

Data Streaming

Once the driver is installed, the overlay is enabled, and OpenEB is available, you can launch the OpenEB viewer:

metavision_viewer

Data Recording and Replay

Display the available command-line options:

metavision_viewer -h

To record a RAW file:

metavision_viewer -o test.raw

Press the space bar to start recording, and press it again to stop.

To replay a previously recorded file:

metavision_viewer -i test.raw

Development with OpenEB

To start developing applications with OpenEB and the Metavision APIs, refer to:

Troubleshooting

Q1: My framerate is lower than expected, and events are being dropped:

A1: There is a known issue where the capture doesn't behave as expected in the first run. The captured framerate is lower than expected and a lot of events are dropped. This can be confirmed with this dmesg output:

[  520.141237] tegra-camrtc-capture-vi tegra-capture-vi: corr_err: discarding frame 0, flags: 0, err_data 131072
[  520.141434] tegra-camrtc-capture-vi tegra-capture-vi: corr_err: discarding frame 0, flags: 0, err_data 512
[  520.142484] tegra-camrtc-capture-vi tegra-capture-vi: corr_err: discarding frame 0, flags: 0, err_data 512
[  520.143424] tegra-camrtc-capture-vi tegra-capture-vi: corr_err: discarding frame 0, flags: 0, err_data 131072
[  520.144844] tegra-camrtc-capture-vi tegra-capture-vi: corr_err: discarding frame 0, flags: 0, err_data 131072
[  520.145369] tegra-camrtc-capture-vi tegra-capture-vi: corr_err: discarding frame 0, flags: 0, err_data 131072
[  520.146887] tegra-camrtc-capture-vi tegra-capture-vi: corr_err: discarding frame 0, flags: 0, err_data 131072

The current workaround is to wait for at least 5 seconds and start capturing again. The framerate will be as expected and the only error you will see in dmesg is this:

[  706.892638] tegra-camrtc-capture-vi tegra-capture-vi: corr_err: discarding frame 0, flags: 0, err_data 512

That message is expected; it is the SoC complaining about the received frame size not being the expected. This is expected as the size of the information sent by the camera depends on the number of events generated. This message can be safely ignored because, although the SoC complains, the data is still moved into memory.

❯

Share This Page

Send Email Using

Jetson Orin NX + Prophesee GenX320

Hardware Setup

Required Hardware

Setup

Software Installation

Step 1: Prepare the Host Build Environment

Step 2: Download and Extract the NVIDIA Toolchain

Step 3: Download the NVIDIA Kernel Sources

Step 4: Apply the RidgeRun GenX320 Kernel Patch

Step 5: Build the Kernel, Modules and Device Trees

Step 6: Copy the Generated Artifacts to the Jetson Orin NX

Step 7: Install and Enable the Driver on the Jetson Orin NX

Step 8: Validate the Driver on the Jetson Orin NX

Step 9: Build and Install OpenEB

Step 10: Configure the Runtime Environment

Running Basic Examples

Data Streaming

Data Recording and Replay

Development with OpenEB

Troubleshooting